home *** CD-ROM | disk | FTP | other *** search
/ GFX Sensations 1 / Graphic Sensations - Volume 1.iso / tools / amiga / 3d_tools / irit40s.lha / Irit / cagd_lib / cagd_lib.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-30  |  35.5 KB  |  752 lines
  1. /******************************************************************************
  2. * Cagd_lib.h - header file for the CAGD library.                  *
  3. * This header is also the interface header to the world.              *
  4. *******************************************************************************
  5. * Written by Gershon Elber, Mar. 90.                          *
  6. ******************************************************************************/
  7.  
  8. #ifndef CAGD_LIB_H
  9. #define CAGD_LIB_H
  10.  
  11. #include <stdio.h>
  12. #include "irit_sm.h"
  13. #include "imalloc.h"
  14. #include "miscattr.h"
  15. #include "genmat.h"
  16.  
  17. typedef int CagdBType;
  18. typedef RealType CagdRType;
  19. typedef RealType CagdUVType[2];
  20. typedef PointType CagdPType;
  21. typedef VectorType CagdVType;
  22. typedef MatrixType CagdMType;
  23. typedef LineType CagdLType;
  24.  
  25. typedef enum {
  26.     CAGD_ERR_180_ARC = 1000,
  27.     CAGD_ERR_AFD_NO_SUPPORT,
  28.     CAGD_ERR_ALLOC_ERR,
  29.     CAGD_ERR_BSPLINE_NO_SUPPORT,
  30.     CAGD_ERR_BZR_CRV_EXPECT,
  31.     CAGD_ERR_BZR_SRF_EXPECT,
  32.     CAGD_ERR_CRV_FAIL_CMPT,
  33.     CAGD_ERR_CRVS_INCOMPATIBLE,
  34.     CAGD_ERR_CUBIC_EXPECTED,
  35.     CAGD_ERR_DEGEN_ALPHA,
  36.     CAGD_ERR_DIR_NOT_CONST_UV,
  37.     CAGD_ERR_INDEX_NOT_IN_MESH,
  38.     CAGD_ERR_KNOT_NOT_ORDERED,
  39.     CAGD_ERR_LIN_NO_SUPPORT,
  40.     CAGD_ERR_NO_CROSS_PROD,
  41.     CAGD_ERR_NOT_ENOUGH_MEM,
  42.     CAGD_ERR_NOT_IMPLEMENTED,
  43.     CAGD_ERR_NUM_KNOT_MISMATCH,
  44.     CAGD_ERR_OUT_OF_RANGE,
  45.     CAGD_ERR_PARSER_STACK_OV,
  46.     CAGD_ERR_POWER_NO_SUPPORT,
  47.     CAGD_ERR_PT_OR_LEN_MISMATCH,
  48.     CAGD_ERR_RATIONAL_EXPECTED,
  49.     CAGD_ERR_SCALAR_EXPECTED,
  50.     CAGD_ERR_SRF_FAIL_CMPT,
  51.     CAGD_ERR_SRFS_INCOMPATIBLE,
  52.     CAGD_ERR_T_NOT_IN_CRV,
  53.     CAGD_ERR_U_NOT_IN_SRF,
  54.     CAGD_ERR_UNDEF_CRV,
  55.     CAGD_ERR_UNDEF_SRF,
  56.     CAGD_ERR_UNSUPPORT_PT,
  57.     CAGD_ERR_V_NOT_IN_SRF,
  58.     CAGD_ERR_W_NOT_SAME,
  59.     CAGD_ERR_WRONG_CRV,
  60.     CAGD_ERR_WRONG_INDEX,
  61.     CAGD_ERR_WRONG_ORDER,
  62.     CAGD_ERR_WRONG_SRF,
  63.     CAGD_ERR_WRONG_PT_TYPE,
  64.     CAGD_ERR_CANNOT_COMP_NORMAL,
  65.     CAGD_ERR_REPARAM_NOT_MONOTONE,
  66.     CAGD_ERR_RATIONAL_NO_SUPPORT,
  67.     CAGD_ERR_NO_SOLUTION,
  68.     CAGD_ERR_TOO_COMPLEX,
  69.     CAGD_ERR_REF_LESS_ORIG,
  70.     CAGD_ERR_ONLY_2D_OR_3D,
  71.  
  72.     CAGD_ERR_UNDEFINE_ERR
  73. } CagdFatalErrorType;
  74.  
  75. typedef enum {        /* Type of control point. The P-types are rationals. */
  76.     CAGD_PT_BASE = 1100,              /* Must be an even number. */
  77.     CAGD_PT_E1_TYPE = 1100,
  78.     CAGD_PT_P1_TYPE,
  79.     CAGD_PT_E2_TYPE,
  80.     CAGD_PT_P2_TYPE,
  81.     CAGD_PT_E3_TYPE,
  82.     CAGD_PT_P3_TYPE,
  83.     CAGD_PT_E4_TYPE,
  84.     CAGD_PT_P4_TYPE,
  85.     CAGD_PT_E5_TYPE,
  86.     CAGD_PT_P5_TYPE
  87. } CagdPointType;
  88.  
  89. #define CAGD_IS_RATIONAL_PT(PType)  (((int) (PType - CAGD_PT_BASE)) & 0x01)
  90. #define CAGD_NUM_OF_PT_COORD(PType) ((((int) (PType - CAGD_PT_BASE)) >> 1) + 1)
  91. #define CAGD_MAKE_PT_TYPE(IsRational, NumCoords) \
  92.                     ((CagdPointType) (CAGD_PT_BASE + \
  93.                          ((((IsRational) ? -1 : -2) \
  94.                             + (NumCoords << 1)))))
  95. #define CAGD_MAX_PT_SIZE        6    /* Rational P5 has 6 coords. */
  96. #define CAGD_MAX_PT_COORD        5               /* Without w. */
  97.  
  98. #define CAGD_IS_RATIONAL_CRV(Crv)    CAGD_IS_RATIONAL_PT(Crv -> PType)
  99. #define CAGD_IS_RATIONAL_SRF(Srf)    CAGD_IS_RATIONAL_PT(Srf -> PType)
  100.  
  101. /* Bezier curves may be evaluated using a predefined cache. The cache must   */
  102. /* be of size (FINENESS) which is power of 2 up to the maximum order below.  */
  103. /* See CrvBzrSetCache routine below.                         */
  104. #define CAGD_MAX_BEZIER_CACHE_ORDER    10
  105. #define CAGD_MAX_BEZIER_CACHE_FINENESS    1024
  106.  
  107. typedef enum {
  108.     CAGD_UNDEF_TYPE = 1200,
  109.     CAGD_CBEZIER_TYPE,
  110.     CAGD_CBSPLINE_TYPE,
  111.     CAGD_CPOWER_TYPE,
  112.     CAGD_SBEZIER_TYPE,
  113.     CAGD_SBSPLINE_TYPE,
  114.     CAGD_SPOWER_TYPE
  115. } CagdGeomType;
  116.  
  117. typedef enum {
  118.     CAGD_NO_DIR = 1300,
  119.     CAGD_CONST_U_DIR,
  120.     CAGD_CONST_V_DIR
  121. } CagdSrfDirType;
  122. #define CAGD_OTHER_DIR(Dir) ((Dir) == CAGD_CONST_U_DIR ? CAGD_CONST_V_DIR \
  123.                                : CAGD_CONST_U_DIR)
  124.  
  125. typedef enum {
  126.     CAGD_REG_POLY_PER_LIN = 1400,
  127.     CAGD_ONE_POLY_PER_LIN,
  128.     CAGD_ONE_POLY_PER_COLIN
  129. } CagdLin2PolyType;
  130.  
  131. typedef struct CagdGenericStruct {
  132.     struct CagdGenericStruct *Pnext;
  133. } CagdGenericStruct;
  134.  
  135. typedef struct CagdUVStruct {
  136.     struct CagdPtStruct *Pnext;
  137.     CagdUVType UV;
  138. } CagdUVStruct;
  139.  
  140. typedef struct CagdPtStruct {
  141.     struct CagdPtStruct *Pnext;
  142.     CagdRType Pt[3];
  143. } CagdPtStruct;
  144.  
  145. typedef struct CagdCtlPtStruct {
  146.     struct CagdCtlPtStruct *Pnext;
  147.     CagdPointType PtType;
  148.     CagdRType Coords[CAGD_MAX_PT_SIZE];
  149. } CagdCtlPtStruct;
  150.  
  151. typedef struct CagdVecStruct {
  152.     struct CagdVecStruct *Pnext;
  153.     CagdRType Vec[3];
  154. } CagdVecStruct;
  155.  
  156. typedef struct CagdPlaneStruct {
  157.     struct CagdPlaneStruct *Pnext;
  158.     CagdRType Plane[4];
  159. } CagdPlaneStruct;
  160.  
  161. typedef struct CagdBBoxStruct {
  162.     struct CagdBBoxStruct *Pnext;
  163.     CagdRType Min[3];
  164.     CagdRType Max[3];
  165. } CagdBBoxStruct;
  166.  
  167. typedef struct CagdCrvStruct {
  168.     struct CagdCrvStruct *Pnext;
  169.     struct IPAttributeStruct *Attr;
  170.     CagdGeomType GType;
  171.     CagdPointType PType;
  172.     int Length;            /* Number of control points (== order in Bezier). */
  173.     int Order;        /* Order of curve (only for Bspline, ignored in Bezier). */
  174.     CagdRType *Points[CAGD_MAX_PT_SIZE];     /* Pointer on each axis vector. */
  175.     CagdRType *KnotVector;
  176. } CagdCrvStruct;
  177.  
  178. typedef struct CagdSrfStruct {
  179.     struct CagdSrfStruct *Pnext;
  180.     struct IPAttributeStruct *Attr;
  181.     CagdGeomType GType;
  182.     CagdPointType PType;
  183.     int ULength, VLength;     /* Mesh size in the tensor product surface. */
  184.     int UOrder, VOrder;   /* Order in tensor product surface (Bspline only). */
  185.     CagdRType *Points[CAGD_MAX_PT_SIZE];     /* Pointer on each axis vector. */
  186.     CagdRType *UKnotVector, *VKnotVector;
  187. } CagdSrfStruct;
  188.  
  189. typedef struct CagdPolygonStruct {
  190.     struct CagdPolygonStruct *Pnext;
  191.     struct IPAttributeStruct *Attr;
  192.     CagdPtStruct Polygon[3];              /* Polygon is always triangle. */
  193.     CagdVecStruct Normal[3];
  194.     CagdUVStruct UV[3];
  195. } CagdPolygonStruct;
  196.  
  197. typedef struct CagdPolylineStruct {
  198.     struct CagdPolylineStruct *Pnext;
  199.     struct IPAttributeStruct *Attr;
  200.     CagdPtStruct *Polyline;         /* Polyline length is defined using Length. */
  201.     int Length;
  202. } CagdPolylineStruct;
  203.  
  204. typedef struct BspKnotAlphaCoeffType {
  205.     int Order, Length, RefLength;     /* The dimensions of the alpha matrix. */
  206.     CagdRType *Matrix;
  207.     CagdRType **Rows;             /* A column of pointers to Matrix rows. */
  208.     int *ColIndex;     /* A row of indices of first non zero value in col. */
  209.     int *ColLength;          /* A row of lengths of non zero values in col. */
  210. } BspKnotAlphaCoeffType;
  211.  
  212. typedef void (*CagdPrintfFuncType)(char *Line);
  213. typedef CagdCrvStruct *(*CagdCrvFuncType)(CagdCrvStruct *Crv, CagdRType R);
  214.  
  215. #define CAGD_IS_BEZIER_CRV(Crv)        (Crv -> GType == CAGD_CBEZIER_TYPE)
  216. #define CAGD_IS_BEZIER_SRF(Srf)        (Srf -> GType == CAGD_SBEZIER_TYPE)
  217. #define CAGD_IS_BSPLINE_CRV(Crv)    (Crv -> GType == CAGD_CBSPLINE_TYPE)
  218. #define CAGD_IS_BSPLINE_SRF(Srf)    (Srf -> GType == CAGD_SBSPLINE_TYPE)
  219. #define CAGD_IS_POWER_CRV(Crv)        (Crv -> GType == CAGD_CPOWER_TYPE)
  220. #define CAGD_IS_POWER_SRF(Srf)        (Srf -> GType == CAGD_SPOWER_TYPE)
  221.  
  222. /******************************************************************************
  223. *        U -->                The mesh is ordered raw after raw *
  224. *       +-----------------------+    or the increments along U are 1 while *
  225. *   V | |P0                 Pi-1|    the increment along V is full raw.    *
  226. *     v    |Pi                P2i-1|        To encapsulate it, NEXTU/V are    *
  227. *    |            |    defined below.                  *
  228. *    |Pn-i            Pn-1|                          *
  229. *    +-----------------------+                          *
  230. ******************************************************************************/
  231. #define CAGD_NEXT_U(Srf)    (1)
  232. #define CAGD_NEXT_V(Srf)    (Srf -> ULength)
  233. #define CAGD_MESH_UV(Srf, i, j)    ((i) + (Srf -> ULength) * (j))
  234.  
  235. /******************************************************************************
  236. * Routines prototypes. Routines are prefixed as follows:              *
  237. * Cagd    - General routines such as dynamic memory handlers etc.          *
  238. * BzrCrv  - Bezier curves routines.                          *
  239. * BzrSrf  - Bezier surface routines.                          *
  240. * BspKnot - Bspline knot vector routines.                      *
  241. * BspCrv  - Bspline curves routines.                          *
  242. * BspSrf  - Bspline surface routines.                          *
  243. * Cnvrt   - Conversion routines such as Bezier to Power basis.              *
  244. ******************************************************************************/
  245.  
  246. #if defined(__cplusplus) || defined(c_plusplus)
  247. extern "C" {
  248. #endif
  249.  
  250. /******************************************************************************
  251. * General routines of the Cagd library:                          *
  252. ******************************************************************************/
  253. void CagdReadSocket(int ReadSocket);
  254. void CagdWriteSocket(int WriteSocket);
  255. void CagdSetFloatFormat(char *FloatFormat);
  256. CagdCrvStruct *CagdCrvNew(CagdGeomType GType, CagdPointType PType, int Length);
  257. CagdSrfStruct *CagdSrfNew(CagdGeomType GType, CagdPointType PType, int ULength,
  258.                                    int VLength);
  259. CagdPolygonStruct *CagdPolygonNew(void);
  260. CagdPolylineStruct *CagdPolylineNew(int Length);
  261. CagdCrvStruct *CagdCrvCopy(CagdCrvStruct *Crv);
  262. CagdSrfStruct *CagdSrfCopy(CagdSrfStruct *Srf);
  263. CagdPolygonStruct *CagdPolygonCopy(CagdPolygonStruct *Poly);
  264. CagdPolylineStruct *CagdPolylineCopy(CagdPolylineStruct *Poly);
  265. void CagdCrvFree(CagdCrvStruct *Crv);
  266. void CagdCrvFreeList(CagdCrvStruct *CrvList);
  267. CagdCrvStruct *CagdCrvCopyList(CagdCrvStruct *CrvList);
  268. void CagdSrfFree(CagdSrfStruct *Srf);
  269. void CagdSrfFreeList(CagdSrfStruct *SrfList);
  270. CagdSrfStruct *CagdSrfCopyList(CagdSrfStruct *SrfList);
  271. void CagdPolylineFree(CagdPolylineStruct *Poly);
  272. void CagdPolylineFreeList(CagdPolylineStruct *PolyList);
  273. CagdPolylineStruct *CagdPolylineCopyList(CagdPolylineStruct *PolyList);
  274. void CagdPolygonFree(CagdPolygonStruct *Poly);
  275. void CagdPolygonFreeList(CagdPolygonStruct *PolyList);
  276. CagdPolygonStruct *CagdPolygonCopyList(CagdPolygonStruct *PolyList);
  277. void CagdPtFreeList(CagdPtStruct *PtList);
  278. void CagdCtlPtFreeList(CagdCtlPtStruct *CtlPtList);
  279. void CagdVecFreeList(CagdVecStruct *VecList);
  280. void CagdPlaneFreeList(CagdPlaneStruct *PlaneList);
  281. void CagdBBoxFreeList(CagdBBoxStruct *BBoxList);
  282. VoidPtr CagdListReverse(VoidPtr List);
  283. void CagdCoerceToE2(CagdRType *E2Point, CagdRType *Points[CAGD_MAX_PT_SIZE],
  284.                          int Index, CagdPointType PType);
  285. void CagdCoerceToE3(CagdRType *E3Point, CagdRType *Points[CAGD_MAX_PT_SIZE],
  286.                          int Index, CagdPointType PType);
  287. void CagdCoerceToP2(CagdRType *P2Point, CagdRType *Points[CAGD_MAX_PT_SIZE],
  288.                          int Index, CagdPointType PType);
  289. void CagdCoerceToP3(CagdRType *P3Point, CagdRType *Points[CAGD_MAX_PT_SIZE],
  290.                          int Index, CagdPointType PType);
  291. void CagdCoercePointTo(CagdRType *NewPoint, CagdPointType NewPType,
  292.                CagdRType *Points[CAGD_MAX_PT_SIZE], int Index,
  293.                CagdPointType OldPType);
  294. void CagdCoercePointsTo(CagdRType *Points[], int Len,
  295.             CagdPointType OldPType, CagdPointType NewPType);
  296. CagdCrvStruct *CagdCoerceCrvTo(CagdCrvStruct *Crv, CagdPointType PType);
  297. CagdSrfStruct *CagdCoerceSrfTo(CagdSrfStruct *Srf, CagdPointType PType);
  298. CagdPointType CagdMergePointType(CagdPointType PType1, CagdPointType PType2);
  299. void CagdMeshAddSub(CagdRType **DestPoints, CagdRType **Points1,
  300.             CagdRType **Points2, CagdPointType PType, int Size,
  301.             CagdBType OperationAdd);
  302. void CagdFatalError(CagdFatalErrorType ErrID);
  303. char *CagdDescribeError(CagdFatalErrorType ErrID);
  304. void CagdDbg(void *Obj);
  305. void CagdSetCagdFprintf(CagdPrintfFuncType Func);
  306. void CagdSetLinear2Poly(CagdLin2PolyType Lin2Poly);
  307. void CagdMergeBBox(CagdBBoxStruct *DestBBox, CagdBBoxStruct *SrcBBox);
  308. CagdRType CagdIChooseK(int i, int k);
  309.  
  310. /******************************************************************************
  311. * Matrix/Vector/Plane/Transformation routines:                      *
  312. ******************************************************************************/
  313. CagdRType CagdDistanceTwoCtlPts(CagdRType **Points, int Index1, int Index2,
  314.                             CagdPointType PType);
  315. CagdRType CagdFitPlaneThruCtlPts(CagdPlaneStruct *Plane, CagdPointType PType,
  316.                      CagdRType **Points,
  317.                      int Index1, int Index2, int Index3, int Index4);
  318. CagdRType CagdDistPtPlane(CagdPlaneStruct *Plane, CagdRType **Points,
  319.                               int Index, int MaxDim);
  320.  
  321. void CagdCrvMatTransform(CagdCrvStruct *Crv, CagdMType Mat);
  322. void CagdSrfMatTransform(CagdSrfStruct *Srf, CagdMType Mat);
  323. void CagdCrvTransform(CagdCrvStruct *Crv, CagdRType *Translate,
  324.                             CagdRType Scale);
  325. void CagdSrfTransform(CagdSrfStruct *Srf, CagdRType *Translate,
  326.                             CagdRType Scale);
  327.  
  328. /******************************************************************************
  329. * Routines to handle curves generically.                      *
  330. ******************************************************************************/
  331. CagdRType CagdEstimateCrvColinearity(CagdCrvStruct *Crv);
  332. void CagdCrvDomain(CagdCrvStruct *Crv, CagdRType *TMin, CagdRType *TMax);
  333. CagdRType *CagdCrvEval(CagdCrvStruct *Crv, CagdRType t);
  334. CagdCrvStruct *CagdCrvDerive(CagdCrvStruct *Crv);
  335. CagdCrvStruct *CagdCrvIntegrate(CagdCrvStruct *Crv);
  336. CagdCrvStruct *CagdCrvEnclosedArea(CagdCrvStruct *Crv);
  337. CagdCrvStruct *CagdCrvSubdivAtParam(CagdCrvStruct *Crv, CagdRType t);
  338. CagdCrvStruct *CagdCrvRegionFromCrv(CagdCrvStruct *Crv, CagdRType t1,
  339.                             CagdRType t2);
  340. CagdCrvStruct *CagdCrvRefineAtParams(CagdCrvStruct *Crv, CagdBType Replace,
  341.                              CagdRType *t, int n);
  342. CagdVecStruct *CagdCrvTangent(CagdCrvStruct *Crv, CagdRType t);
  343. CagdVecStruct *CagdCrvBiNormal(CagdCrvStruct *Crv, CagdRType t);
  344. CagdVecStruct *CagdCrvNormal(CagdCrvStruct *Crv, CagdRType t);
  345. CagdCrvStruct *CagdCrvOffset(CagdCrvStruct *Crv, CagdRType OffsetDist);
  346. CagdCrvStruct *CagdCrvAdapOffset(CagdCrvStruct *OrigCrv,
  347.                  CagdRType OffsetDist,
  348.                  CagdRType OffsetError,
  349.                  CagdCrvFuncType OffsetAprxFunc);
  350. CagdCrvStruct *CagdCrvAdapOffsetTrim(CagdCrvStruct *OrigCrv,
  351.                      CagdRType OffsetDist,
  352.                      CagdRType OffsetError,
  353.                      CagdCrvFuncType OffsetAprxFunc);
  354. CagdCrvStruct *CagdCrvReverse(CagdCrvStruct *Crv);
  355. CagdCrvStruct *CagdCrvDegreeRaise(CagdCrvStruct *Crv);
  356. CagdCrvStruct *CagdCrvDegreeRaiseN(CagdCrvStruct *Crv, int NewOrder);
  357. CagdCrvStruct *CagdMergeCrvCrv(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  358. CagdCrvStruct *CagdMergeCrvList(CagdCrvStruct *CrvList);
  359. CagdCrvStruct *CagdMergeCrvPt(CagdCrvStruct *Crv, CagdPtStruct *Pt);
  360. CagdCrvStruct *CagdMergePtCrv(CagdPtStruct *Pt, CagdCrvStruct *Crv);
  361. CagdCrvStruct *CagdMergePtPt(CagdPtStruct *Pt1, CagdPtStruct *Pt2);
  362. CagdPolylineStruct *CagdCrv2CtrlPoly(CagdCrvStruct *Crv);
  363. CagdPolylineStruct *CagdCrv2Polyline(CagdCrvStruct *Crv, int SamplesPerCurve);
  364. CagdCrvStruct *CagdEditSingleCrvPt(CagdCrvStruct *Crv, CagdCtlPtStruct *CtlPt,
  365.                            int Index, CagdBType Write);
  366. CagdCrvStruct *CagdCrvReadFromFile(char *FileName, char **ErrStr, int *Line);
  367. CagdCrvStruct *CagdCrvReadFromFile2(FILE *f, char **ErrStr, int *Line);
  368. int CagdCrvWriteToFile(CagdCrvStruct *Crvs, char *FileName, int Indent,
  369.                          char *Comment,    char **ErrStr);
  370. int CagdCrvWriteToFile2(CagdCrvStruct *Crvs, FILE *f, int Indent, char *Comment,
  371.                                 char **ErrStr);
  372. CagdBType CagdMakeCrvsCompatible(CagdCrvStruct **Crv1, CagdCrvStruct **Crv2,
  373.                  CagdBType SameOrder, CagdBType SameKV);
  374. void CagdCrvBBox(CagdCrvStruct *Crv, CagdBBoxStruct *BBox);
  375. void CagdCrvListBBox(CagdCrvStruct *Crvs, CagdBBoxStruct *BBox);
  376. void CagdCrvMinMax(CagdCrvStruct *Crv, int Axis,
  377.            CagdRType *Min, CagdRType *Max);
  378. int CagdCrvEvalToPolyline(CagdCrvStruct *Crv, int FineNess,
  379.               CagdRType *Points[], BspKnotAlphaCoeffType *A);
  380. void CagdCrvSplitScalar(CagdCrvStruct *Crv, CagdCrvStruct **CrvW,
  381.          CagdCrvStruct **CrvX, CagdCrvStruct **CrvY, CagdCrvStruct **CrvZ);
  382. CagdCrvStruct *CagdCrvMergeScalar(CagdCrvStruct *CrvW,
  383.         CagdCrvStruct *CrvX, CagdCrvStruct *CrvY, CagdCrvStruct *CrvZ);
  384. CagdCrvStruct *CagdCrvAdd(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  385. CagdCrvStruct *CagdCrvSub(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  386. CagdCrvStruct *CagdCrvReciprocal(CagdCrvStruct *Crv);
  387. CagdCrvStruct *CagdCrvMult(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  388. CagdCrvStruct *CagdCrvDotProd(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  389. CagdCrvStruct *CagdCrvCrossProd(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  390. CagdCrvStruct *CagdCrvRtnlMult(CagdCrvStruct *Crv1X, CagdCrvStruct *Crv1W,
  391.                    CagdCrvStruct *Crv2X, CagdCrvStruct *Crv2W,
  392.                    CagdBType OperationAdd);
  393. CagdCrvStruct *CagdCrvCurvatureSqr(CagdCrvStruct *Crv);
  394. CagdCrvStruct *CagdCrvCurvatureNormal(CagdCrvStruct *Crv);
  395. CagdCrvStruct *CagdCrvCurvatureSign(CagdCrvStruct *Crv);
  396. CagdPtStruct *CagdCrvInflectionPts(CagdCrvStruct *Crv, CagdRType Epsilon);
  397. CagdPtStruct *CagdCrvExtremCrvtrPts(CagdCrvStruct *Crv, CagdRType Epsilon);
  398. CagdPtStruct *CagdCrvZeroSet(CagdCrvStruct *Crv, int Axis, CagdRType Epsilon);
  399. CagdPtStruct *CagdCrvExtremSet(CagdCrvStruct *Crv, int Axis, CagdRType Epsilon);
  400. CagdPtStruct *CagdCrvConstSet(CagdCrvStruct *Crv, int Axis, CagdRType Epsilon,
  401.                                CagdRType ConstVal);
  402. CagdBType CagdCrvPosNegWeights(CagdCrvStruct *Crv);
  403. CagdCrvStruct *CagdCrvUnitLenScalar(CagdCrvStruct *OrigCrv, CagdBType Mult,
  404.                                CagdRType Epsilon);
  405. CagdCrvStruct *CagdCrvSqrtScalar(CagdCrvStruct *OrigCrv, CagdRType Epsilon);
  406. CagdCrvStruct *CagdCrvArcLenCrv(CagdCrvStruct *OrigCrv, CagdRType Epsilon);
  407. CagdCrvStruct *CagdMakePosCrvCtlPolyPos(CagdCrvStruct *OrigCrv);
  408. CagdCrvStruct *CagdComposeCrvCrv(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  409. CagdCrvStruct *CagdComposeSrfCrv(CagdSrfStruct *Srf, CagdCrvStruct *Crv);
  410. CagdCrvStruct *CagdLimitCrvArcLen(CagdCrvStruct *Crv, CagdRType MaxLen);
  411. CagdRType CagdCrvArcLenPoly(CagdCrvStruct *Crv);
  412. CagdRType CagdCrvArcLen(CagdCrvStruct *Crv, CagdRType Epsilon);
  413. CagdPtStruct *CagdCrvArcLenSteps(CagdCrvStruct *Crv, CagdRType Length,
  414.                                 CagdRType Epsilon);
  415.  
  416. /******************************************************************************
  417. * Routines to handle surfaces generically.                      *
  418. ******************************************************************************/
  419. CagdRType CagdEstimateSrfPlanarity(CagdSrfStruct *Srf);
  420. void CagdSrfDomain(CagdSrfStruct *Srf, CagdRType *UMin, CagdRType *UMax,
  421.                        CagdRType *VMin, CagdRType *VMax);
  422. CagdRType *CagdSrfEval(CagdSrfStruct *Srf, CagdRType u, CagdRType v);
  423. CagdSrfStruct *CagdSrfDerive(CagdSrfStruct *Srf, CagdSrfDirType Dir);
  424. CagdCrvStruct *CagdCrvFromSrf(CagdSrfStruct *Srf, CagdRType t,
  425.                             CagdSrfDirType Dir);
  426. CagdCrvStruct *CagdCrvFromMesh(CagdSrfStruct *Srf, int Index,
  427.                             CagdSrfDirType Dir);
  428. void CagdCrvToMesh(CagdCrvStruct *Crv, int Index,
  429.                        CagdSrfDirType Dir, CagdSrfStruct *Srf);
  430. CagdSrfStruct *CagdSrfSubdivAtParam(CagdSrfStruct *Srf, CagdRType t,
  431.                                CagdSrfDirType Dir);
  432. CagdSrfStruct *CagdSrfRegionFromSrf(CagdSrfStruct *Srf, CagdRType t1,
  433.                          CagdRType t2, CagdSrfDirType Dir);
  434. CagdSrfStruct *CagdSrfRefineAtParams(CagdSrfStruct *Srf, CagdSrfDirType Dir,
  435.                        CagdBType Replace, CagdRType *t, int n);
  436. CagdVecStruct *CagdSrfTangent(CagdSrfStruct *Srf, CagdRType u, CagdRType v,
  437.                                CagdSrfDirType Dir);
  438. CagdVecStruct *CagdSrfNormal(CagdSrfStruct *Srf, CagdRType u, CagdRType v);
  439. CagdSrfStruct *CagdSrfOffset(CagdSrfStruct *Srf, CagdRType OffsetDist);
  440. CagdSrfStruct *CagdSrfDegreeRaise(CagdSrfStruct *Srf, CagdSrfDirType Dir);
  441. CagdSrfStruct *CagdSrfReverse(CagdSrfStruct *Srf);
  442. CagdSrfStruct *CagdSrfReverse2(CagdSrfStruct *Srf);
  443. CagdPolylineStruct *CagdSrf2CtrlMesh(CagdSrfStruct *Srf);
  444. CagdSrfStruct *CagdMergeSrfSrf(CagdSrfStruct *Srf1, CagdSrfStruct *Srf2,
  445.                    CagdSrfDirType Dir, CagdBType SameEdge);
  446. CagdSrfStruct *CagdMergeSrfList(CagdSrfStruct *SrfList, CagdSrfDirType Dir,
  447.                             CagdBType SameEdge);
  448. CagdPolygonStruct *CagdSrf2Polygons(CagdSrfStruct *Srf, int FineNess,
  449.     CagdBType ComputeNormals, CagdBType FourPerFlat, CagdBType ComputeUV);
  450. CagdPolylineStruct *CagdSrf2Polylines(CagdSrfStruct *Srf, int NumOfIsocurves[2],
  451.                               int SamplesPerCurve);
  452. CagdCrvStruct *CagdSrf2Curves(CagdSrfStruct *Srf, int NumOfIsocurves[2]);
  453. CagdSrfStruct *CagdSrfReadFromFile(char *FileName, char **ErrStr, int *Line);
  454. CagdSrfStruct *CagdSrfReadFromFile2(FILE *f, char **ErrStr, int *Line);
  455. int CagdSrfWriteToFile(CagdSrfStruct *Srfs, char *FileName, int Indent,
  456.                          char *Comment,    char **ErrStr);
  457. int CagdSrfWriteToFile2(CagdSrfStruct *Srfs, FILE *f, int Indent, char *Comment,
  458.                                 char **ErrStr);
  459. CagdSrfStruct *CagdExtrudeSrf(CagdCrvStruct *Crv, CagdVecStruct *Vec);
  460. CagdSrfStruct *CagdSurfaceRev(CagdCrvStruct *Crv);
  461. CagdSrfStruct *CagdSweepSrf(CagdCrvStruct *CrossSection, CagdCrvStruct *Axis,
  462.                 CagdCrvStruct *ScalingCrv, CagdRType Scale,
  463.                 VoidPtr Frame, CagdBType FrameIsCrv);
  464. CagdSrfStruct *CagdBoolSumSrf(CagdCrvStruct *CrvLeft,
  465.                   CagdCrvStruct *CrvRight,
  466.                   CagdCrvStruct *CrvTop,
  467.                   CagdCrvStruct *CrvBottom);
  468. CagdSrfStruct *CagdOneBoolSumSrf(CagdCrvStruct *BndryCrv);
  469. CagdSrfStruct *CagdRuledSrf(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2,
  470.                 int OtherOrder, int OtherLen);
  471. CagdSrfStruct *CagdPromoteCrvToSrf(CagdCrvStruct *Crv, CagdSrfDirType Dir);
  472. CagdSrfStruct *CagdSrfFromCrvs(CagdCrvStruct *CrvList, int OtherOrder);
  473. CagdBType CagdMakeSrfsCompatible(CagdSrfStruct **Srf1, CagdSrfStruct **Srf2,
  474.                  CagdBType SameUOrder, CagdBType SameVOrder,
  475.                  CagdBType SameUKV, CagdBType SameVKV);
  476. CagdSrfStruct *CagdEditSingleSrfPt(CagdSrfStruct *Srf, CagdCtlPtStruct *CtlPt,
  477.                       int UIndex, int VIndex, CagdBType Write);
  478. void CagdSrfBBox(CagdSrfStruct *Srf, CagdBBoxStruct *BBox);
  479. void CagdSrfListBBox(CagdSrfStruct *Srfs, CagdBBoxStruct *BBox);
  480. void CagdSrfMinMax(CagdSrfStruct *Srf, int Axis,
  481.            CagdRType *Min, CagdRType *Max);
  482. CagdSrfStruct *CagdTwoSrfsMorphing(CagdSrfStruct *Srf1, CagdSrfStruct *Srf2,
  483.                                   CagdRType Blend);
  484. void CagdSrfSplitScalar(CagdSrfStruct *Srf, CagdSrfStruct **SrfW,
  485.          CagdSrfStruct **SrfX, CagdSrfStruct **SrfY, CagdSrfStruct **SrfZ);
  486. CagdSrfStruct *CagdSrfMergeScalar(CagdSrfStruct *SrfW,
  487.         CagdSrfStruct *SrfX, CagdSrfStruct *SrfY, CagdSrfStruct *SrfZ);
  488. CagdSrfStruct *CagdSrfAdd(CagdSrfStruct *Srf1, CagdSrfStruct *Srf2);
  489. CagdSrfStruct *CagdSrfSub(CagdSrfStruct *Srf1, CagdSrfStruct *Srf2);
  490. CagdSrfStruct *CagdSrfReciprocal(CagdSrfStruct *Srf);
  491. CagdSrfStruct *CagdSrfMult(CagdSrfStruct *Srf1, CagdSrfStruct *Srf2);
  492. CagdSrfStruct *CagdSrfDotProd(CagdSrfStruct *Srf1, CagdSrfStruct *Srf2);
  493. CagdSrfStruct *CagdSrfCrossProd(CagdSrfStruct *Srf1, CagdSrfStruct *Srf2);
  494. CagdSrfStruct *CagdSrfNormalSrf(CagdSrfStruct *Srf);
  495. CagdSrfStruct *CagdSrfRtnlMult(CagdSrfStruct *Srf1X, CagdSrfStruct *Srf1W,
  496.                    CagdSrfStruct *Srf2X, CagdSrfStruct *Srf2W,
  497.                    CagdBType OperationAdd);
  498. CagdCrvStruct *CagdPrmtSclrCrvTo2D(CagdCrvStruct *Crv, CagdRType Min,
  499.                                 CagdRType Max);
  500. CagdSrfStruct *CagdPrmtSclrSrfTo3D(CagdSrfStruct *Srf,
  501.                    CagdRType UMin, CagdRType UMax,
  502.                    CagdRType VMin, CagdRType VMax);
  503. void CagdSetAdapIsoExtractMinLevel(int MinLevel);
  504. CagdCrvStruct *CagdAdapIsoExtract(CagdSrfStruct *Srf, CagdSrfStruct *NSrf,
  505.                   CagdSrfDirType Dir,
  506.                   CagdRType Eps, CagdBType FullIso,
  507.                   CagdBType SinglePath);
  508. CagdSrfStruct *CagdPiecewiseRuledSrfApprox(CagdSrfStruct *Srf,
  509.                        CagdBType ConsistentDir,
  510.                        CagdRType Epsilon,
  511.                        CagdSrfDirType Dir);
  512. CagdSrfStruct *CagdPrisaRuledSrf(CagdSrfStruct *Srf, int SamplesPerCurve,
  513.                  CagdRType Space, CagdVType Offset);
  514. CagdSrfStruct *CagdAllPrisaSrfs(CagdSrfStruct *Srfs, int SamplesPerCurve,
  515.                 CagdRType Epsilon, CagdSrfDirType Dir,
  516.                 CagdVType Space);
  517. CagdSrfStruct *CagdSrfDistCrvCrv(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  518. CagdPtStruct *CagdSrfDistFindPoints(CagdSrfStruct *Srf, CagdRType Epsilon,
  519.                             CagdBType SelfInter);
  520. CagdRType CagdDistCrvPoint(CagdCrvStruct *Crv, CagdPType Pt,
  521.                      CagdBType MinDist, CagdRType Epsilon);
  522. CagdPtStruct *CagdLclDistCrvPoint(CagdCrvStruct *Crv, CagdPType Pt,
  523.                                 CagdRType Epsilon);
  524. CagdRType CagdDistCrvLine(CagdCrvStruct *Crv, CagdLType Line,
  525.                      CagdBType MinDist, CagdRType Epsilon);
  526. CagdPtStruct *CagdLclDistCrvLine(CagdCrvStruct *Crv, CagdLType Line,
  527.                                 CagdRType Epsilon);
  528.  
  529. /******************************************************************************
  530. * Routines to handle Bezier curves.                          *
  531. ******************************************************************************/
  532. CagdCrvStruct *BzrCrvReadFromFile(char *FileName, char **ErrStr, int *ErrLine);
  533. CagdCrvStruct *BzrCrvReadFromFile2(FILE *f, CagdBType NameWasRead,
  534.                           char **ErrStr, int *ErrLine);
  535. int BzrCrvWriteToFile(CagdCrvStruct *Crvs, char *FileName, int Indent,
  536.                          char *Comment,    char **ErrStr);
  537. int BzrCrvWriteToFile2(CagdCrvStruct *Crvs, FILE *f, int Indent, char *Comment,
  538.                                 char **ErrStr);
  539. CagdCrvStruct *BzrCrvNew(int Length, CagdPointType PType);
  540. CagdRType BzrCrvEvalVecAtParam(CagdRType *Vec, int VecInc, int Order,
  541.                                 CagdRType t);
  542. CagdRType *BzrCrvEvalAtParam(CagdCrvStruct *Crv, CagdRType t);
  543. void BzrCrvSetCache(int FineNess, CagdBType EnableCache);
  544. void BzrCrvEvalToPolyline(CagdCrvStruct *Crv, int FineNess,
  545.                             CagdRType *Points[]);
  546. CagdCrvStruct *BzrCrvCreateArc(CagdPtStruct *Start, CagdPtStruct *Center,
  547.                                 CagdPtStruct *End);
  548. CagdCrvStruct *BzrCrvSubdivAtParam(CagdCrvStruct *Crv, CagdRType t);
  549. CagdCrvStruct *BzrCrvDegreeRaise(CagdCrvStruct *Crv);
  550. CagdCrvStruct *BzrCrvDegreeRaiseN(CagdCrvStruct *Crv, int NewOrder);
  551. CagdCrvStruct *BzrCrvDerive(CagdCrvStruct *Crv);
  552. CagdCrvStruct *BzrCrvIntegrate(CagdCrvStruct *Crv);
  553. CagdCrvStruct *BzrCrvDeriveRational(CagdCrvStruct *Crv);
  554. CagdVecStruct *BzrCrvTangent(CagdCrvStruct *Crv, CagdRType t);
  555. CagdVecStruct *BzrCrvBiNormal(CagdCrvStruct *Crv, CagdRType t);
  556. CagdVecStruct *BzrCrvNormal(CagdCrvStruct *Crv, CagdRType t);
  557. CagdCrvStruct *BzrCrvInterpolate(int Size, CagdRType *XVec, CagdRType *YVec,
  558.                                   CagdRType *ZVec);
  559. CagdPolylineStruct *BzrCrv2Polyline(CagdCrvStruct *Crv, int SamplesPerCurve);
  560. CagdCrvStruct *BzrCrvMult(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  561. CagdCrvStruct *BzrCrvMultList(CagdCrvStruct *Crv1Lst, CagdCrvStruct *Crv2Lst);
  562. CagdCrvStruct *BzrApproxBzrCrvAsCubics(CagdCrvStruct *Crv, CagdRType Tol,
  563.                        CagdRType MaxLen, CagdBType NoRational);
  564. CagdCrvStruct *BzrApproxBzrCrvAsCubicPoly(CagdCrvStruct *Crv, CagdRType Tol2);
  565. CagdCrvStruct *BzrComposeCrvCrv(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  566. CagdCrvStruct *BzrComposeSrfCrv(CagdSrfStruct *Srf, CagdCrvStruct *Crv);
  567.  
  568. /******************************************************************************
  569. * Routines to handle Bezier surfaces.                          *
  570. ******************************************************************************/
  571. CagdSrfStruct *BzrSrfReadFromFile(char *FileName, char **ErrStr, int *ErrLine);
  572. CagdSrfStruct *BzrSrfReadFromFile2(FILE *f, CagdBType NameWasRead,
  573.                           char **ErrStr, int *ErrLine);
  574. int BzrSrfWriteToFile(CagdSrfStruct *Srfs, char *FileName, int Indent,
  575.                          char *Comment,    char **ErrStr);
  576. int BzrSrfWriteToFile2(CagdSrfStruct *Srfs, FILE *f, int Indent, char *Comment,
  577.                                 char **ErrStr);
  578. CagdSrfStruct *BzrSrfNew(int ULength, int VLength, CagdPointType PType);
  579. CagdRType *BzrSrfEvalAtParam(CagdSrfStruct *Srf, CagdRType u, CagdRType v);
  580. CagdCrvStruct *BzrSrfCrvFromSrf(CagdSrfStruct *Srf, CagdRType t,
  581.                             CagdSrfDirType Dir);
  582. CagdCrvStruct *BzrSrfCrvFromMesh(CagdSrfStruct *Srf, int Index,
  583.                             CagdSrfDirType Dir);
  584. CagdSrfStruct *BzrSrfSubdivAtParam(CagdSrfStruct *Srf, CagdRType t,
  585.                             CagdSrfDirType Dir);
  586. CagdSrfStruct *BzrSrfDegreeRaise(CagdSrfStruct *Srf, CagdSrfDirType Dir);
  587. CagdSrfStruct *BzrSrfDerive(CagdSrfStruct *Srf, CagdSrfDirType Dir);
  588. CagdSrfStruct *BzrSrfDeriveRational(CagdSrfStruct *Srf, CagdSrfDirType Dir);
  589. CagdVecStruct *BzrSrfTangent(CagdSrfStruct *Srf, CagdRType u, CagdRType v,
  590.                              CagdSrfDirType Dir);
  591. CagdVecStruct *BzrSrfNormal(CagdSrfStruct *Srf, CagdRType u, CagdRType v);
  592. CagdPolygonStruct *BzrSrf2Polygons(CagdSrfStruct *Srf, int FineNess,
  593.      CagdBType ComputeNormals, CagdBType FourPerFlat, CagdBType ComputeUV);
  594. CagdPolylineStruct *BzrSrf2Polylines(CagdSrfStruct *Srf, int NumOfIsocurves[2],
  595.                             int SamplesPerCurve);
  596. CagdCrvStruct *BzrSrf2Curves(CagdSrfStruct *Srf, int NumOfIsocurves[2]);
  597. CagdSrfStruct *BzrSrfMult(CagdSrfStruct *Srf1, CagdSrfStruct *Srf2);
  598.  
  599. /******************************************************************************
  600. * Routines to handle Bspline knot vectors.                      *
  601. ******************************************************************************/
  602. CagdBType BspKnotHasOpenEC(CagdRType *KnotVector, int Len, int Order);
  603. CagdBType BspKnotParamInDomain(CagdRType *KnotVector, int Len, int Order,
  604.                                 CagdRType t);
  605. int BspKnotLastIndexLE(CagdRType *KnotVector, int Len, CagdRType t);
  606. int BspKnotLastIndexL(CagdRType *KnotVector, int Len, CagdRType t);
  607. int BspKnotFirstIndexG(CagdRType *KnotVector, int Len, CagdRType t);
  608. CagdRType *BspKnotUniformFloat(int Len, int Order, CagdRType *KnotVector);
  609. CagdRType *BspKnotUniformOpen(int Len, int Order, CagdRType *KnotVector);
  610. CagdRType *BspKnotSubtrTwo(CagdRType *KnotVector1, int Len1,
  611.                CagdRType *KnotVector2, int Len2,
  612.                int *NewLen);
  613. CagdRType *BspKnotMergeTwo(CagdRType *KnotVector1, int Len1,
  614.                CagdRType *KnotVector2, int Len2,
  615.                int Mult, int *NewLen);
  616. CagdRType *BspKnotNodes(CagdRType *KnotVector, int Len, int Order);
  617. CagdRType *BspKnotPrepEquallySpaced(int n, CagdRType Tmin, CagdRType Tmax);
  618. CagdRType *BspKnotReverse(CagdRType *KnotVector, int Len);
  619. void BspKnotAffineTrans(CagdRType *KnotVector, int Len,
  620.                     CagdRType Translate, CagdRType Scale);
  621. CagdRType *BspKnotCopy(CagdRType *KnotVector, int Len);
  622. BspKnotAlphaCoeffType *BspKnotEvalAlphaCoef(int k, CagdRType *KVT,
  623.                 int LengthKVT, CagdRType *KVt, int LengthKVt);
  624. BspKnotAlphaCoeffType *BspKnotEvalAlphaCoefMerge(int k, CagdRType *KVT,
  625.                 int LengthKVT, CagdRType *NewKV, int LengthNewKV);
  626. void BspKnotFreeAlphaCoef(BspKnotAlphaCoeffType *A);
  627. CagdRType *BspKnotInsertOne(CagdRType *KnotVector, int Order, int Len,
  628.                                  CagdRType t);
  629. CagdRType *BspKnotInsertMult(CagdRType *KnotVector, int Order, int *Len,
  630.                                CagdRType t, int Mult);
  631. int BspKnotFindMult(CagdRType *KnotVector, int Order, int Len, CagdRType t);
  632. CagdBType BspKnotC1Discont(CagdRType *KnotVector, int Order, int Length,
  633.                                 CagdRType *t);
  634. CagdRType *BspKnotAllC1Discont(CagdRType *KnotVector, int Order, int Length,
  635.                                       int *n);
  636. CagdRType *BspKnotParamValues(CagdRType PMin, CagdRType PMax, int NumSamples,
  637.                   CagdRType *C1Disconts, int NumC1Disconts);
  638. void BspKnotMakeRobustKV(CagdRType *KV, int Len);
  639.  
  640. /******************************************************************************
  641. * Routines to handle Bspline curves.                          *
  642. ******************************************************************************/
  643. CagdCrvStruct *BspCrvReadFromFile(char *FileName, char **ErrStr, int *ErrLine);
  644. CagdCrvStruct *BspCrvReadFromFile2(FILE *f, CagdBType NameWasRead,
  645.                           char **ErrStr, int *ErrLine);
  646. int BspCrvWriteToFile(CagdCrvStruct *Crvs, char *FileName, int Indent,
  647.                          char *Comment,    char **ErrStr);
  648. int BspCrvWriteToFile2(CagdCrvStruct *Crvs, FILE *f, int Indent, char *Comment,
  649.                                 char **ErrStr);
  650. CagdCrvStruct *BspCrvNew(int Length, int Order, CagdPointType PType);
  651. void BspCrvDomain(CagdCrvStruct *Crv, CagdRType *TMin, CagdRType *TMax);
  652.  
  653. CagdRType *BspCrvCoxDeBoorBasis(CagdRType *KnotVector, int Order, int Len,
  654.                         CagdRType t, int *IndexFirst);
  655. CagdRType *BspCrvEvalCoxDeBoor(CagdCrvStruct *Crv, CagdRType t);
  656. CagdRType BspCrvEvalVecAtParam(CagdRType *Vec, int VecInc,
  657.                    CagdRType *KnotVector, int Order, int Len,
  658.                    CagdRType t);
  659. CagdRType *BspCrvEvalAtParam(CagdCrvStruct *Crv, CagdRType t);
  660. CagdCrvStruct *BspCrvCreateCircle(CagdPtStruct *Center, CagdRType Radius);
  661. CagdCrvStruct *BspCrvCreateUnitCircle(void);
  662. CagdCrvStruct *BspCrvKnotInsert(CagdCrvStruct *Crv, CagdRType t);
  663. CagdCrvStruct *BspCrvKnotInsertNSame(CagdCrvStruct *Crv, CagdRType t, int n);
  664. CagdCrvStruct *BspCrvKnotInsertNDiff(CagdCrvStruct *Crv, CagdBType Replace,
  665.                               CagdRType *t, int n);
  666. CagdCrvStruct *BspCrvSubdivAtParam(CagdCrvStruct *Crv, CagdRType t);
  667. CagdCrvStruct *BspCrvDegreeRaise(CagdCrvStruct *Crv);
  668. CagdCrvStruct *BspCrvDegreeRaiseN(CagdCrvStruct *Crv, int NewOrder);
  669. CagdCrvStruct *BspCrvDerive(CagdCrvStruct *Crv);
  670. CagdCrvStruct *BspCrvIntegrate(CagdCrvStruct *Crv);
  671. CagdCrvStruct *BspCrvDeriveRational(CagdCrvStruct *Crv);
  672. CagdVecStruct *BspCrvTangent(CagdCrvStruct *Crv, CagdRType t);
  673. CagdVecStruct *BspCrvBiNormal(CagdCrvStruct *Crv, CagdRType t);
  674. CagdVecStruct *BspCrvNormal(CagdCrvStruct *Crv, CagdRType t);
  675. CagdPolylineStruct *BspCrv2Polyline(CagdCrvStruct *Crv, int SamplesPerCurve,
  676.                              BspKnotAlphaCoeffType *A);
  677. CagdCrvStruct *BspCrvMult(CagdCrvStruct *Crv1, CagdCrvStruct *Crv2);
  678.  
  679. /******************************************************************************
  680. * Routines to handle Bspline surfaces.                          *
  681. ******************************************************************************/
  682. CagdSrfStruct *BspSrfReadFromFile(char *FileName, char **ErrStr, int *ErrLine);
  683. CagdSrfStruct *BspSrfReadFromFile2(FILE *f, CagdBType NameWasRead,
  684.                           char **ErrStr, int *ErrLine);
  685. int BspSrfWriteToFile(CagdSrfStruct *Srfs, char *FileName, int Indent,
  686.                          char *Comment,    char **ErrStr);
  687. int BspSrfWriteToFile2(CagdSrfStruct *Srfs, FILE *f, int Indent, char *Comment,
  688.                                 char **ErrStr);
  689. CagdSrfStruct *BspSrfNew(int ULength, int VLength,
  690.              int UOrder, int VOrder, CagdPointType PType);
  691. void BspSrfDomain(CagdSrfStruct *Srf, CagdRType *UMin, CagdRType *UMax,
  692.                       CagdRType *VMin, CagdRType *VMax);
  693. CagdRType *BspSrfEvalAtParam(CagdSrfStruct *Srf, CagdRType u, CagdRType v);
  694. CagdCrvStruct *BspSrfCrvFromSrf(CagdSrfStruct *Srf, CagdRType t,
  695.                             CagdSrfDirType Dir);
  696. CagdCrvStruct *BspSrfCrvFromMesh(CagdSrfStruct *Srf, int Index,
  697.                             CagdSrfDirType Dir);
  698. CagdSrfStruct *BspSrfKnotInsert(CagdSrfStruct *Srf, CagdSrfDirType Dir,
  699.                                   CagdRType t);
  700. CagdSrfStruct *BspSrfKnotInsertNSame(CagdSrfStruct *Srf, CagdSrfDirType Dir,
  701.                                CagdRType t, int n);
  702. CagdSrfStruct *BspSrfKnotInsertNDiff(CagdSrfStruct *Srf, CagdSrfDirType Dir,
  703.                          int Replace, CagdRType *t, int n);
  704. CagdSrfStruct *BspSrfSubdivAtParam(CagdSrfStruct *Srf, CagdRType t,
  705.                             CagdSrfDirType Dir);
  706. CagdSrfStruct *BspSrfDegreeRaise(CagdSrfStruct *Srf, CagdSrfDirType Dir);
  707. CagdSrfStruct *BspSrfDerive(CagdSrfStruct *Srf, CagdSrfDirType Dir);
  708. CagdSrfStruct *BspSrfDeriveRational(CagdSrfStruct *Srf, CagdSrfDirType Dir);
  709. CagdVecStruct *BspSrfTangent(CagdSrfStruct *Srf, CagdRType u, CagdRType v,
  710.                              CagdSrfDirType Dir);
  711. CagdVecStruct *BspSrfNormal(CagdSrfStruct *Srf, CagdRType u, CagdRType v);
  712. CagdVecStruct *BspSrfMeshNormals(CagdSrfStruct *Srf, int UFineNess,
  713.                                 int VFineNess);
  714. CagdPolygonStruct *BspSrf2Polygons(CagdSrfStruct *Srf, int FineNess,
  715.      CagdBType ComputeNormals, CagdBType FourPerFlat, CagdBType ComputeUV);
  716. CagdPolylineStruct *BspSrf2Polylines(CagdSrfStruct *Srf, int NumOfIsocurves[2],
  717.                             int SamplesPerCurve);
  718. CagdCrvStruct *BspSrf2Curves(CagdSrfStruct *Srf, int NumOfIsocurves[2]);
  719. CagdSrfStruct *BspSrfMult(CagdSrfStruct *Srf1, CagdSrfStruct *Srf2);
  720.  
  721. /******************************************************************************
  722. * Routines to handle basis function conversions.                  *
  723. ******************************************************************************/
  724. CagdCrvStruct *CnvrtPower2BezierCrv(CagdCrvStruct *Crv);
  725. CagdCrvStruct *CnvrtBezier2PowerCrv(CagdCrvStruct *Crv);
  726. CagdCrvStruct *CnvrtBspline2BezierCrv(CagdCrvStruct *Crv);
  727. CagdCrvStruct *CnvrtBezier2BsplineCrv(CagdCrvStruct *Crv);
  728.  
  729. CagdSrfStruct *CnvrtPower2BezierSrf(CagdSrfStruct *Srf);
  730. CagdSrfStruct *CnvrtBezier2PowerSrf(CagdSrfStruct *Srf);
  731. CagdSrfStruct *CnvrtBezier2BsplineSrf(CagdSrfStruct *Srf);
  732. CagdSrfStruct *CnvrtBspline2BezierSrf(CagdSrfStruct *Srf);
  733.  
  734. CagdCrvStruct *CnvrtPolyline2LinBsplineCrv(CagdPolylineStruct *Poly);
  735.  
  736. /******************************************************************************
  737. * Routines to handle adaptive forward differencing basis functions.          *
  738. ******************************************************************************/
  739. void AfdCnvrtCubicBzrToAfd(CagdRType Coef[4]);
  740. void AfdApplyLn(CagdRType Coef[4], int n);
  741. void AfdApplyEStep(CagdRType Coef[4]);
  742. void AfdComputePolyline(CagdRType Coef[4], CagdRType *Poly, int Log2Step,
  743.                             CagdBType NonAdaptive);
  744. void AfdBzrCrvEvalToPolyline(CagdCrvStruct *Crv, int FineNess,
  745.                             CagdRType *Points[]);
  746.  
  747. #if defined(__cplusplus) || defined(c_plusplus)
  748. }
  749. #endif
  750.  
  751. #endif /* CAGD_LIB_H */
  752.